home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / config / tm-hp9k320.h < prev    next >
C/C++ Source or Header  |  1992-06-08  |  20KB  |  597 lines
  1. /* Definitions of target machine for GNU compiler.  HP-UX 68000/68020 version.
  2.    Copyright (C) 1987, 1988 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* Define USE_GAS if GCC is supposed to work with the GNU assembler,
  21.    GNU linker and GNU debugger using DBX debugging information.
  22.    (In other words, much of HPUX has been cast aside.)
  23.    Undefine USE_GAS if you want GCC to feed the HP assembler.  */
  24.  
  25. /* #define USE_GAS */  /* Use tm-hp9k320g.h if you want this.  */
  26.  
  27. /* Control assembler-syntax conditionals in m68k.md.  */
  28.  
  29. #ifndef USE_GAS
  30. #define MOTOROLA
  31. #define SGS
  32. #define HPUX_ASM
  33. #endif
  34.  
  35. #include "tm-m68k.h"
  36.  
  37. /* See tm-m68k.h.  7 means 68020 with 68881.  */
  38.  
  39. #ifndef TARGET_DEFAULT
  40. #define    TARGET_DEFAULT 7
  41. #endif
  42.  
  43. /* Define __HAVE_68881__ in preprocessor, unless -msoft-float is specified.
  44.    This will control the use of inline 68881 insns in certain macros.  */
  45.  
  46. /* For version 6.2 of HP-UX (or earlier), remove the "-V 3" from
  47.    ASM_SPEC below. */
  48.  
  49. #ifdef HPUX_ASM
  50.  
  51. #define ASM_SPEC "%{m68000:+X} -V 3"
  52.  
  53. #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  54.  
  55. /* These definitions differ from those used for GAS by defining __HPUX_ASM__.
  56.    This is needed because some programs, particularly GDB, need to
  57.    know which assembler is being used so that the correct `asm'
  58.    instructions can be used. */
  59.  
  60. #define CPP_SPEC \
  61. "%{!msoft-float:-D__HAVE_68881__ }\
  62. %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}}} -D__HPUX_ASM__"
  63.  
  64. #else /* default is -msoft-float */
  65.  
  66. #define CPP_SPEC \
  67. "%{m68881:-D__HAVE_68881__ }\
  68. %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}}} -D__HPUX_ASM__"
  69.  
  70. #endif /* default is -msoft-float */
  71.  
  72. #else /* not HPUX_ASM */
  73.  
  74. #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  75.  
  76. #define CPP_SPEC \
  77. "%{!msoft-float:-D__HAVE_68881__ }\
  78. %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}}}"
  79.  
  80. #else /* default is -msoft-float */
  81.  
  82. #define CPP_SPEC \
  83. "%{m68881:-D__HAVE_68881__ }\
  84. %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}}}"
  85.  
  86. #endif /* default is -msoft-float */
  87.  
  88.  
  89. /* -m68000 requires special flags to the assembler.  */
  90. #define ASM_SPEC \
  91.  "%{m68000:-mc68000}%{mc68000:-mc68000}%{!mc68000:%{!m68000:-mc68020}}"
  92.  
  93. /* special directory for gnu libs on hp-ux system */
  94. #undef STANDARD_STARTFILE_PREFIX
  95. #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/gnu/"
  96.  
  97. #endif /* Not HPUX_ASM */
  98.  
  99. /* Names to predefine in the preprocessor for this target machine
  100.    (for non-strict-ANSI programs only).  */
  101. /* These are the ones defined by HPUX cc, plus mc68000 for uniformity with
  102.    GCC on other 68000 systems.  */
  103.  
  104. #define CPP_PREDEFINES "-Dhp9000s200 -Dhp9000s300 -DPWB -Dhpux -Dunix -D__hp9000s300 -D_HPUX_SOURCE"
  105.  
  106. /* Every structure or union's size must be a multiple of 2 bytes.  */
  107.  
  108. #define STRUCTURE_SIZE_BOUNDARY 16
  109.  
  110. /* hpux doesn't use static area for struct returns. */
  111. #undef PCC_STATIC_STRUCT_RETURN
  112.  
  113. /* Generate calls to memcpy, memcmp and memset.  */
  114. #define TARGET_MEM_FUNCTIONS
  115.  
  116. /* Function calls don't save any fp registers on hpux.  */
  117.  
  118. #undef CALL_USED_REGISTERS
  119. #define CALL_USED_REGISTERS                        \
  120.  {1, 1, 0, 0, 0, 0, 0, 0,                        \
  121.   1, 1, 0, 0, 0, 0, 0, 1,                        \
  122.   1, 1, 1, 1, 1, 1, 1, 1}
  123.  
  124. #ifdef HPUX_ASM
  125.  
  126. /* Override parts of tm-m68k.h to fit the HPUX assembler.  */
  127.  
  128. #undef TARGET_VERSION
  129. #undef REGISTER_NAMES
  130. #undef FUNCTION_PROLOGUE
  131. #undef FUNCTION_EPILOGUE
  132. #undef ASM_OUTPUT_REG_PUSH
  133. #undef ASM_OUTPUT_REG_POP
  134. #undef ASM_FILE_START
  135. #undef ASM_APP_ON
  136. #undef ASM_APP_OFF
  137. #undef TEXT_SECTION_ASM_OP
  138. #undef DATA_SECTION_ASM_OP
  139. #undef ASM_OUTPUT_DOUBLE
  140. #undef ASM_OUTPUT_FLOAT
  141. #undef ASM_OUTPUT_INT
  142. #undef ASM_OUTPUT_SHORT
  143. #undef ASM_OUTPUT_CHAR
  144. #undef ASM_OUTPUT_BYTE
  145. #undef ASM_OUTPUT_ADDR_VEC_ELT
  146. #undef ASM_OUTPUT_ADDR_DIFF_ELT
  147. #undef ASM_OUTPUT_ALIGN
  148. #undef ASM_OUTPUT_SKIP
  149. #undef ASM_OUTPUT_COMMON
  150. #undef ASM_OUTPUT_LOCAL
  151. #undef ASM_FORMAT_PRIVATE_NAME
  152. #undef PRINT_OPERAND
  153. #undef PRINT_OPERAND_ADDRESS
  154. #undef FUNCTION_PROFILER
  155. #undef ASM_GLOBALIZE_LABEL
  156. #undef ASM_OUTPUT_INTERNAL_LABEL
  157.  
  158. #define TARGET_VERSION fprintf (stderr, " (68k, SGS/hpux syntax)");
  159.  
  160. #define REGISTER_NAMES \
  161. {"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",    \
  162.  "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp",    \
  163.  "%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7"}
  164.  
  165. #define FUNCTION_PROLOGUE(FILE, SIZE)     \
  166. { register int regno;                        \
  167.   register int mask = 0;                    \
  168.   extern char call_used_regs[];                    \
  169.   int fsize = (SIZE);                        \
  170.   if (frame_pointer_needed)                    \
  171.     { if (fsize < 0x8000)                    \
  172.         fprintf (FILE, "\tlink.w %%a6,&%d\n", -fsize);        \
  173.       else if (TARGET_68020)                    \
  174.         fprintf (FILE, "\tlink.l %%a6,&%d\n", -fsize);        \
  175.       else                            \
  176.     fprintf (FILE, "\tlink.w %%a6,&0\n\tsub.l &%d,%%sp\n", fsize); }  \
  177.   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)    \
  178.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  179.        mask |= 1 << (regno - 16);                \
  180.   if (mask != 0)                        \
  181.     fprintf (FILE, "\tfmovem &0x%x,-(%%sp)\n", mask & 0xff);       \
  182.   mask = 0;                            \
  183.   for (regno = 0; regno < 16; regno++)                \
  184.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  185.        mask |= 1 << (15 - regno);                \
  186.   if (frame_pointer_needed)                    \
  187.     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));            \
  188.   if (exact_log2 (mask) >= 0)                    \
  189.     fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[15 - exact_log2 (mask)]);  \
  190.   else if (mask) fprintf (FILE, "\tmovm.l &0x%x,-(%%sp)\n", mask); }
  191.  
  192. #define FUNCTION_PROFILER(FILE, LABEL_NO) \
  193.    fprintf (FILE, "\tmov.l &LP%d,%%a0\n\tjsr mcount\n", (LABEL_NO));
  194.  
  195. #define FUNCTION_EPILOGUE(FILE, SIZE) \
  196. { register int regno;                        \
  197.   register int mask, fmask;                    \
  198.   register int nregs;                        \
  199.   int offset, foffset;                        \
  200.   extern char call_used_regs[];                    \
  201.   extern int current_function_pops_args;            \
  202.   extern int current_function_args_size;            \
  203.   int fsize = (SIZE);                        \
  204.   int big = 0;                            \
  205.   nregs = 0;  fmask = 0;                    \
  206.   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)    \
  207.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  208.       { nregs++; fmask |= 1 << (23 - regno); }            \
  209.   foffset = nregs * 12;                        \
  210.   nregs = 0;  mask = 0;                        \
  211.   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
  212.   for (regno = 0; regno < 16; regno++)                \
  213.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  214.       { nregs++; mask |= 1 << regno; }                \
  215.   offset = foffset + nregs * 4;                    \
  216.   if (offset + fsize >= 0x8000 && frame_pointer_needed)        \
  217.     { fprintf (FILE, "\tmov.l &%d,%%a0\n", -fsize);        \
  218.       fsize = 0, big = 1; }                    \
  219.   if (exact_log2 (mask) >= 0) {                    \
  220.     if (big)                            \
  221.       fprintf (FILE, "\tmov.l -%d(%%a6,%%a0.l),%s\n",        \
  222.            offset + fsize, reg_names[exact_log2 (mask)]);    \
  223.     else if (! frame_pointer_needed)                \
  224.       fprintf (FILE, "\tmov.l (%%sp)+,%s\n",            \
  225.            reg_names[exact_log2 (mask)]);            \
  226.     else                            \
  227.       fprintf (FILE, "\tmov.l -%d(%%a6),%s\n",            \
  228.            offset + fsize, reg_names[exact_log2 (mask)]); }    \
  229.   else if (mask) {                        \
  230.     if (big)                            \
  231.       fprintf (FILE, "\tmovm.l -%d(%%a6,%%a0.l),&0x%x\n",    \
  232.            offset + fsize, mask);                \
  233.     else if (! frame_pointer_needed)                \
  234.       fprintf (FILE, "\tmovm.l (%%sp)+,&0x%x\n", mask);        \
  235.     else                            \
  236.       fprintf (FILE, "\tmovm.l -%d(%%a6),&0x%x\n",        \
  237.            offset + fsize, mask); }                \
  238.   if (fmask) {                            \
  239.     if (big)                            \
  240.       fprintf (FILE, "\tfmovem -%d(%%a6,%%a0.l),&0x%x\n",    \
  241.            foffset + fsize, fmask);                \
  242.     else if (! frame_pointer_needed)                \
  243.       fprintf (FILE, "\tfmovem (%%sp)+,&0x%x\n", fmask);    \
  244.     else                            \
  245.       fprintf (FILE, "\tfmovem -%d(%%a6),&0x%x\n",        \
  246.            foffset + fsize, fmask); }            \
  247.   if (frame_pointer_needed)                    \
  248.     fprintf (FILE, "\tunlk %%a6\n");                \
  249.   if (current_function_pops_args && current_function_args_size)    \
  250.     fprintf (FILE, "\trtd &%d\n", current_function_args_size);    \
  251.   else fprintf (FILE, "\trts\n"); }
  252.  
  253. /* This is how to output an insn to push a register on the stack.
  254.    It need not be very fast code.  */
  255.  
  256. #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
  257.   fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[REGNO])
  258.  
  259. /* This is how to output an insn to pop a register from the stack.
  260.    It need not be very fast code.  */
  261.  
  262. #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
  263.   fprintf (FILE, "\tmov.l (%%sp)+,%s\n", reg_names[REGNO])
  264.  
  265. #define ASM_FILE_START(FILE)
  266.  
  267. #define ASM_APP_ON ""
  268.  
  269. #define ASM_APP_OFF ""
  270.  
  271. #define TEXT_SECTION_ASM_OP "text"
  272.  
  273. #define DATA_SECTION_ASM_OP "data"
  274.  
  275. #define    ASCII_DATA_ASM_OP "\tbyte"
  276.  
  277. /* This says how to output an assembler line
  278.    to define a global common symbol.  */
  279.  
  280. #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
  281. ( fputs ("\tcomm ", (FILE)),            \
  282.   assemble_name ((FILE), (NAME)),        \
  283.   fprintf ((FILE), ",%d\n", (ROUNDED)))
  284.  
  285. /* This says how to output an assembler line
  286.    to define a local common symbol.  */
  287.  
  288. #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
  289. ( fputs ("\tlcomm ", (FILE)),            \
  290.   assemble_name ((FILE), (NAME)),        \
  291.   fprintf ((FILE), ",%d,2\n", (ROUNDED)))
  292.  
  293. /* Store in OUTPUT a string (made with alloca) containing
  294.    an assembler-name for a local static variable named NAME.
  295.    LABELNO is an integer which is different for each call.  */
  296.  
  297. #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)    \
  298. ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
  299.   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
  300.  
  301. /* This is how to output a command to make the user-level label named NAME
  302.    defined for reference from other files.  */
  303.  
  304. #define ASM_GLOBALIZE_LABEL(FILE,NAME)    \
  305.   do { fputs ("\tglobal ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0)
  306.  
  307. #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)    \
  308. do{  if (PREFIX[0] == 'L' && PREFIX[1] == 'I')        \
  309.     fprintf(FILE, "\tset %s%d,.+2\n", PREFIX, NUM);    \
  310.   else                            \
  311.     fprintf (FILE, "%s%d:\n", PREFIX, NUM);        \
  312. } while(0)
  313.  
  314. #define ASM_OUTPUT_DOUBLE(FILE, VALUE)                    \
  315.   fprintf (FILE, "\tdouble 0f%.20g\n", (VALUE))
  316.  
  317. #define ASM_OUTPUT_FLOAT(FILE, VALUE)                    \
  318.   fprintf (FILE, "\tfloat 0f%.9g\n", (VALUE))
  319.  
  320. /* This is how to output an assembler line defining an `int' constant.  */
  321.  
  322. #define ASM_OUTPUT_INT(FILE,VALUE)  \
  323. ( fprintf (FILE, "\tlong "),            \
  324.   output_addr_const (FILE, (VALUE)),        \
  325.   fprintf (FILE, "\n"))
  326.  
  327. /* Likewise for `char' and `short' constants.  */
  328.  
  329. #define ASM_OUTPUT_SHORT(FILE,VALUE)  \
  330. ( fprintf (FILE, "\tshort "),            \
  331.   output_addr_const (FILE, (VALUE)),        \
  332.   fprintf (FILE, "\n"))
  333.  
  334. #define ASM_OUTPUT_CHAR(FILE,VALUE)  \
  335. ( fprintf (FILE, "\tbyte "),            \
  336.   output_addr_const (FILE, (VALUE)),        \
  337.   fprintf (FILE, "\n"))
  338.  
  339. /* This is how to output an assembler line for a numeric constant byte.  */
  340.  
  341. #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
  342.   fprintf (FILE, "\tbyte 0x%x\n", (VALUE))
  343.  
  344. #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
  345.   fprintf (FILE, "\tlong L%d\n", VALUE)
  346.  
  347. #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  \
  348.   fprintf (FILE, "\tshort L%d-L%d\n", VALUE, REL)
  349.  
  350. #define ASM_OUTPUT_ALIGN(FILE,LOG)    \
  351.   if ((LOG) == 1)            \
  352.     fprintf (FILE, "\tlalign 2\n");    \
  353.   else if ((LOG) != 0)            \
  354.     abort ();
  355.  
  356. #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
  357.   fprintf (FILE, "\tspace %d\n", (SIZE))
  358.  
  359. #define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME)
  360. #define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO)
  361.  
  362. #define PRINT_OPERAND(FILE, X, CODE)  \
  363. { if (CODE == '.') fprintf (FILE, ".");                    \
  364.   else if (CODE == '#') fprintf (FILE, "&");                \
  365.   else if (CODE == '-') fprintf (FILE, "-(%%sp)");            \
  366.   else if (CODE == '+') fprintf (FILE, "(%%sp)+");            \
  367.   else if (CODE == '@') fprintf (FILE, "(%%sp)");            \
  368.   else if (CODE == '!') fprintf (FILE, "%%cc");                \
  369.   else if (GET_CODE (X) == REG)                        \
  370.     fprintf (FILE, "%s", reg_names[REGNO (X)]);                \
  371.   else if (GET_CODE (X) == MEM)                        \
  372.     output_address (XEXP (X, 0));                    \
  373.   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)    \
  374.     { union { double d; int i[2]; } u;                    \
  375.       union { float f; int i; } u1;                    \
  376.       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
  377.       u1.f = u.d;                            \
  378.       if (CODE == 'f')                            \
  379.         fprintf (FILE, "&0f%.9g", u1.f);                \
  380.       else                                \
  381.         fprintf (FILE, "&0x%x", u1.i); }                \
  382.   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)    \
  383.     { union { double d; int i[2]; } u;                    \
  384.       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
  385.       fprintf (FILE, "&0f%.20g", u.d); }                \
  386.   else { putc ('&', FILE); output_addr_const (FILE, X); }}
  387.  
  388. #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
  389. { register rtx reg1, reg2, breg, ireg;                    \
  390.   register rtx addr = ADDR;                        \
  391.   rtx offset;                                \
  392.   switch (GET_CODE (addr))                        \
  393.     {                                    \
  394.     case REG:                                \
  395.       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);            \
  396.       break;                                \
  397.     case PRE_DEC:                            \
  398.       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);    \
  399.       break;                                \
  400.     case POST_INC:                            \
  401.       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);    \
  402.       break;                                \
  403.     case PLUS:                                \
  404.       reg1 = 0;    reg2 = 0;                        \
  405.       ireg = 0;    breg = 0;                        \
  406.       offset = 0;                            \
  407.       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                \
  408.     {                                \
  409.       offset = XEXP (addr, 0);                    \
  410.       addr = XEXP (addr, 1);                    \
  411.     }                                \
  412.       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))            \
  413.     {                                \
  414.       offset = XEXP (addr, 1);                    \
  415.       addr = XEXP (addr, 0);                    \
  416.     }                                \
  417.       if (GET_CODE (addr) != PLUS) ;                    \
  418.       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)        \
  419.     {                                \
  420.       reg1 = XEXP (addr, 0);                    \
  421.       addr = XEXP (addr, 1);                    \
  422.     }                                \
  423.       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)        \
  424.     {                                \
  425.       reg1 = XEXP (addr, 1);                    \
  426.       addr = XEXP (addr, 0);                    \
  427.     }                                \
  428.       else if (GET_CODE (XEXP (addr, 0)) == MULT)            \
  429.     {                                \
  430.       reg1 = XEXP (addr, 0);                    \
  431.       addr = XEXP (addr, 1);                    \
  432.     }                                \
  433.       else if (GET_CODE (XEXP (addr, 1)) == MULT)            \
  434.     {                                \
  435.       reg1 = XEXP (addr, 1);                    \
  436.       addr = XEXP (addr, 0);                    \
  437.     }                                \
  438.       else if (GET_CODE (XEXP (addr, 0)) == REG)            \
  439.     {                                \
  440.       reg1 = XEXP (addr, 0);                    \
  441.       addr = XEXP (addr, 1);                    \
  442.     }                                \
  443.       else if (GET_CODE (XEXP (addr, 1)) == REG)            \
  444.     {                                \
  445.       reg1 = XEXP (addr, 1);                    \
  446.       addr = XEXP (addr, 0);                    \
  447.     }                                \
  448.       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT        \
  449.       || GET_CODE (addr) == SIGN_EXTEND)                \
  450.     { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }    \
  451. /*  for OLD_INDEXING                            \
  452.       else if (GET_CODE (addr) == PLUS)                    \
  453.     {                                \
  454.       if (GET_CODE (XEXP (addr, 0)) == REG)                \
  455.         {                                \
  456.           reg2 = XEXP (addr, 0);                    \
  457.           addr = XEXP (addr, 1);                    \
  458.         }                                \
  459.       else if (GET_CODE (XEXP (addr, 1)) == REG)            \
  460.         {                                \
  461.           reg2 = XEXP (addr, 1);                    \
  462.           addr = XEXP (addr, 0);                    \
  463.         }                                \
  464.     }                                \
  465.   */                                    \
  466.       if (offset != 0) { if (addr != 0) abort (); addr = offset; }    \
  467.       if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND            \
  468.             || GET_CODE (reg1) == MULT))            \
  469.       || (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2))))        \
  470.     { breg = reg2; ireg = reg1; }                    \
  471.       else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1)))        \
  472.     { breg = reg1; ireg = reg2; }                    \
  473.       if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF)    \
  474.         { int scale = 1;                        \
  475.       if (GET_CODE (ireg) == MULT)                    \
  476.         { scale = INTVAL (XEXP (ireg, 1));                \
  477.           ireg = XEXP (ireg, 0); }                    \
  478.       if (GET_CODE (ireg) == SIGN_EXTEND)                \
  479.         fprintf (FILE, "L%d-LI%d(%%pc,%s.w",            \
  480.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  481.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  482.              reg_names[REGNO (XEXP (ireg, 0))]);         \
  483.       else                                \
  484.         fprintf (FILE, "L%d-LI%d(%%pc,%s.l",            \
  485.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  486.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  487.              reg_names[REGNO (ireg)]);                \
  488.       if (scale != 1) fprintf (FILE, "*%d", scale);            \
  489.       putc (')', FILE);                        \
  490.       break; }                            \
  491.       if (ireg != 0 || breg != 0)                    \
  492.     { int scale = 1;                        \
  493.       if (breg == 0)                        \
  494.         abort ();                            \
  495.       if (addr != 0)                        \
  496.         output_addr_const (FILE, addr);                \
  497.       fprintf (FILE, "(%s", reg_names[REGNO (breg)]);        \
  498.       if (ireg != 0)                        \
  499.         putc (',', FILE);                        \
  500.       if (ireg != 0 && GET_CODE (ireg) == MULT)            \
  501.         { scale = INTVAL (XEXP (ireg, 1));                \
  502.           ireg = XEXP (ireg, 0); }                    \
  503.       if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)        \
  504.         fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);    \
  505.       else if (ireg != 0)                        \
  506.         fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);        \
  507.       if (scale != 1) fprintf (FILE, "*%d", scale);            \
  508.       putc (')', FILE);                        \
  509.       break;                            \
  510.     }                                \
  511.       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)        \
  512.     { fprintf (FILE, "L%d-LI%d(%%pc,%s.w)",                \
  513.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  514.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  515.            reg_names[REGNO (reg1)]);                \
  516.       break; }                            \
  517.     default:                                \
  518.       if (GET_CODE (addr) == CONST_INT                    \
  519.       && INTVAL (addr) < 0x8000                    \
  520.       && INTVAL (addr) >= -0x8000)                    \
  521.     fprintf (FILE, "%d.w", INTVAL (addr));                \
  522.       else                                \
  523.         output_addr_const (FILE, addr);                    \
  524.     }}
  525.  
  526. #define    ASM_OUTPUT_ASCII(f, p, size)    \
  527. { register int i;            \
  528.   int inside;                \
  529.   inside = FALSE;            \
  530.   for (i = 0; i < size; i++) {        \
  531.     if (i % 8 == 0) {            \
  532.       if (i != 0) {            \
  533.     if (inside)            \
  534.       putc('"', f);            \
  535.     putc('\n', f);            \
  536.     inside = FALSE;            \
  537.       }                    \
  538.       fprintf(f, "%s ", ASCII_DATA_ASM_OP);    \
  539.     }                    \
  540.     if (p[i] < 32 || p[i] == '\\' || p[i] == '"' || p[i] == 127) {    \
  541.       if (inside) {            \
  542.     putc('"', f);            \
  543.     inside = FALSE;            \
  544.       }                    \
  545.       if (i % 8 != 0)            \
  546.     putc(',', f);            \
  547.       fprintf(f, "%d", p[i]);        \
  548.     } else {                \
  549.       if (!inside) {            \
  550.     if (i % 8 != 0)            \
  551.       putc(',', f);            \
  552.     putc('"', f);            \
  553.     inside = TRUE;            \
  554.       }                    \
  555.       putc(p[i], f);            \
  556.     }                    \
  557.   }                    \
  558.   if (inside)                \
  559.     putc('"', f);            \
  560.   putc('\n', f);            \
  561. }
  562.  
  563. /* Translate Motorola opcodes such as `jbeq'
  564.    into SGS opcodes such as `beq.w'.
  565.    Delete the `e' in `move...' and `fmove'.
  566.    Change `ftst' to `ftest'.  */
  567.  
  568. #define ASM_OUTPUT_OPCODE(FILE, PTR)            \
  569. { if ((PTR)[0] == 'j' && (PTR)[1] == 'b')        \
  570.     { ++(PTR);                        \
  571.       while (*(PTR) != ' ')                \
  572.     { putc (*(PTR), (FILE)); ++(PTR); }        \
  573.       fprintf ((FILE), ".w"); }                \
  574.   else if ((PTR)[0] == 'f')                \
  575.     {                            \
  576.       if (!strncmp ((PTR), "fmove", 5))            \
  577.     { fprintf ((FILE), "fmov"); (PTR) += 5; }    \
  578.       else if (!strncmp ((PTR), "ftst", 4))        \
  579.     { fprintf ((FILE), "ftest"); (PTR) += 4; }    \
  580.     }                            \
  581.   else if ((PTR)[0] == 'm' && (PTR)[1] == 'o'        \
  582.        && (PTR)[2] == 'v' && (PTR)[3] == 'e')    \
  583.     { fprintf ((FILE), "mov"); (PTR) += 4; }        \
  584. }
  585.  
  586. /* Prevent output of `gcc_compiled.:'.  */
  587.  
  588. #define ASM_IDENTIFY_GCC(FILE)
  589.  
  590. #else /* not HPUX_ASM */
  591.  
  592. #undef FUNCTION_PROFILER
  593. #define FUNCTION_PROFILER(FILE, LABELNO)  \
  594.    fprintf (FILE, "\tmovl #LP%d,d0\n\tjsr mcount\n", (LABELNO));
  595.  
  596. #endif /* not HPUX_ASM */
  597.